const std = @import("std");

// CPU管理器
pub const CpuManager = struct {
    // 时间片分配信息
    current_time_slice: u32 = 0,
    remaining_time: u32 = 0,

    // 初始化CPU管理器
    pub fn init() CpuManager {
        return CpuManager{};
    }

    // 初始化控制寄存器（在实际系统中会设置CR0、CR3、CR4等）
    pub fn initControlRegisters(_: *CpuManager) void {
        // 在实际系统中，这里会设置各种CPU控制寄存器
        std.log.info("Initializing CPU control registers", .{});
    }

    // 分配CPU时间片
    pub fn allocateTimeSlice(self: *CpuManager, milliseconds: u32) bool {
        self.current_time_slice = milliseconds;
        self.remaining_time = milliseconds;
        std.log.info("Allocated CPU time slice: {} ms", .{milliseconds});
        return true;
    }

    // 更新时间片（在时钟中断中调用）
    pub fn updateTimeSlice(self: *CpuManager, elapsed_ms: u32) bool {
        if (self.remaining_time > elapsed_ms) {
            self.remaining_time -= elapsed_ms;
            return true; // 时间片尚未用完
        } else {
            self.remaining_time = 0;
            return false; // 时间片已用完，需要重新调度
        }
    }

    // 获取当前时间片剩余时间
    pub fn getRemainingTime(self: *CpuManager) u32 {
        return self.remaining_time;
    }

    // 设置CPU特权级别（在实际系统中会修改CS寄存器）
    pub fn setPrivilegeLevel(level: u8) bool {
        if (level > 3) {
            return false;
        }
        std.log.info("Setting CPU privilege level to {}", .{level});
        return true;
    }

    // 禁用中断
    pub fn disableInterrupts() void {
        std.log.info("Disabling CPU interrupts", .{});
        // 在实际系统中，这里会执行 CLI 指令
    }

    // 启用中断
    pub fn enableInterrupts() void {
        std.log.info("Enabling CPU interrupts", .{});
        // 在实际系统中，这里会执行 STI 指令
    }

    // 从端口读取字节
    pub fn inb(port: u16) u8 {
        std.log.debug("Reading from port 0x{X}", .{port});
        // 在实际系统中，这里会执行 IN 指令
        return 0;
    }

    // 向端口写入字节
    pub fn outb(port: u16, value: u8) void {
        std.log.debug("Writing 0x{X} to port 0x{X}", .{ value, port });
        // 在实际系统中，这里会执行 OUT 指令
    }

    // CPU 空闲状态
    pub fn idle() void {
        std.log.debug("CPU entering idle state", .{});
        // 在实际系统中，这里会执行 HLT 指令
    }
};

// 全局CPU管理器实例
pub var global_cpu_manager: CpuManager = undefined;

// 初始化全局CPU管理器
pub fn initGlobalCpuManager() void {
    global_cpu_manager = CpuManager.init();
    global_cpu_manager.initControlRegisters();
    std.log.info("Global CPU manager initialized", .{});
}

// 获取全局CPU管理器
pub fn getGlobalCpuManager() *CpuManager {
    return &global_cpu_manager;
}

// 清理CPU管理器
pub fn deinitGlobalCpuManager() void {
    std.log.info("Global CPU manager deinitialized", .{});
}